Introduction to JavaServer Pages (JSP)

Course: Advanced Java Training

Topic: Introduction to JavaServer Pages (JSP)

Course Link: Advanced Java Training Course

Demo Link: Register for a Course Demo

Website: JustAcademy

1. Introduction to JavaServer Pages

JavaServer Pages (JSP) is a server-side Java technology used to create dynamic web pages. It allows developers to combine HTML markup with JSP elements, Expression Language (EL), and tag libraries to display information generated by a Java web application.

JSP is especially useful for building the presentation layer of web applications. Instead of returning only static HTML, a JSP page can display information such as a user's profile, a list of products, student records, order details, or messages generated by the application.

For example, an online shopping website may use a JSP page to display product names and prices retrieved from a database. The Java application retrieves the data, and the JSP renders it into HTML that the browser can display.

Why Is JSP Used?

• To generate dynamic HTML pages using server-side Java application data.
• To separate the presentation layer from business logic.
• To display data supplied by servlets and Java classes.
• To create reusable page fragments such as headers, navigation menus, and footers.
• To access JavaBean properties through Expression Language.
• To simplify the development of Java-based web applications.

2. What Is a Dynamic Web Page?

A dynamic web page is a page whose content can change depending on user input, database records, application state, or other server-side information.

Static vs Dynamic Web Pages

3. How JSP Works

A JSP page is processed by a JSP container, which is typically integrated with a servlet container. The container translates the JSP page into a servlet implementation, compiles it if necessary, and executes it to generate the response.

JSP Processing Flow

Client Browser
      |
      | HTTP Request
      v
Web Server / Servlet Container
      |
      v
JSP Container
      |
      | Translate JSP into Servlet
      v
Compile Generated Servlet
      |
      v
Execute Servlet
      |
      v
Generate HTML Response
      |
      v
Client Browser Displays Page

Step-by-Step Explanation

1. Request: The browser requests a JSP resource from the web application.
2. Translation: If the JSP needs processing, the container translates it into servlet source code.
3. Compilation: The generated servlet source is compiled into Java bytecode.
4. Initialization: The container initializes the generated servlet as required.
5. Request processing: The generated servlet executes the page's processing logic.
6. Response generation: The server produces the resulting HTML or other configured response content.
7. Browser rendering: The browser receives and renders the response.

The initial request may trigger translation and compilation. Subsequent requests usually reuse the compiled servlet until the JSP changes or the container otherwise needs to recompile it.

4. JSP and Servlet Relationship

JSP and servlets are closely related technologies. A servlet is a Java class that processes requests and generates responses. JSP provides a template-oriented way to define a response, especially HTML, and is translated into a servlet by the container.

Developers commonly use servlets or other Java components to coordinate request processing and use JSP pages to render the resulting data.

Example Architecture

Browser
   |
   v
StudentServlet
   |
   | Retrieves student data
   v
Java Service / DAO
   |
   | Returns student information
   v
StudentServlet
   |
   | Stores data in request attributes
   v
student-details.jsp
   |
   | Renders HTML using EL
   v
Browser Displays Student Details

JSP vs Servlet

5. Setting Up a JSP Development Environment

To develop JSP applications, you need a Java development environment, a compatible servlet container, and a project configured with the correct Servlet and JSP API versions.

Required Tools

• JDK: Provides the Java compiler and runtime environment.
• IDE: Eclipse, IntelliJ IDEA, or another Java IDE can be used.
• Servlet container: Apache Tomcat or another compatible Jakarta EE server.
• Web project: A project configured to package and deploy JSP files and Java classes.
• Browser: Used to test the deployed application.

Important Compatibility Note

Modern Jakarta EE applications use packages such as jakarta.servlet. Older Java EE applications use javax.servlet. Ensure that your server, project dependencies, and Java imports are compatible. A JSP page may look similar across versions, but the underlying APIs and supported specifications can differ.

6. Creating Your First JSP Page

A JSP file can contain ordinary HTML and JSP-specific elements. Create a file named index.jsp inside your web application's web root.

Example: Hello JSP

<%@ page language="java"
    contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8" %>
<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>My First JSP Page</title>
</head>
<body>
    <h1>Welcome to JSP</h1>
    <p>This page is generated by a Java web application.</p>
</body>
</html>

Explanation

• <%@ page ... %> is a JSP page directive.
• contentType defines the response content type and character encoding.
• pageEncoding specifies the character encoding of the JSP source file.
• The HTML elements define the page's structure and visible content.
• The JSP container processes the file and generates a response when the page is requested.

After deploying the project to a compatible server, open the page using the application's local server URL. The exact URL depends on your project name, server port, and context path.

7. JSP Page Directives

Directives provide instructions to the JSP container about how a JSP page should be translated and processed. The main directive types are page, include, and taglib.

7.1 Page Directive

The page directive configures page-level properties such as content type, character encoding, imports, and error-page behavior.

<%@ page language="java"
    contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"
    import="java.time.LocalDate" %>

<h2>Today's Date</h2>
<p><%= LocalDate.now() %></p>

This example demonstrates the syntax, but in a well-structured application, date or business calculations are generally prepared in a Java component and exposed to the JSP for display.

7.2 Include Directive

The include directive includes the contents of another file during JSP translation. It is commonly used for shared page fragments.

<%@ include file="header.jsp" %>

<main>
    <h2>Student Dashboard</h2>
    <p>Welcome to the portal.</p>
</main>

<%@ include file="footer.jsp" %>

The included file is incorporated during translation. This is useful for relatively stable template fragments such as shared HTML headers and footers.

7.3 Taglib Directive

The taglib directive declares a tag library so its tags can be used in a JSP. The Jakarta Standard Tag Library (JSTL) provides useful tags for iteration, conditional rendering, and other common view operations.

<%@ taglib prefix="c"
    uri="jakarta.tags.core" %>

<c:if test="${not empty studentName}">
    <p>Student: ${studentName}</p>
</c:if>

The tag library URI and dependency must match the JSTL version used by your application. The example uses the URI associated with modern Jakarta Tags.

8. JSP Scripting Elements

JSP supports three traditional scripting elements: declarations, scriptlets, and expressions. Although they remain important for understanding existing JSP applications, modern JSP development generally favors Expression Language and tag libraries over embedding Java code directly in pages.

8.1 Declaration

A declaration uses <%! ... %> to declare fields or methods in the generated servlet class.

<%!
    public String getApplicationTitle() {
        return "Student Portal";
    }
%>

<h2><%= getApplicationTitle() %></h2>

Important: Fields declared this way may be shared by concurrent requests because the generated servlet instance can process requests using multiple threads. Avoid mutable request-specific fields in JSP declarations.

8.2 Scriptlet

A scriptlet uses <% ... %> to embed Java statements inside a JSP.

<%
    String name = "Aarav";
    int age = 21;
%>

<p>Name: <%= name %></p>
<p>Age: <%= age %></p>

Scriptlets are useful to recognize in legacy code, but they can mix business logic with presentation. Prefer preparing data in a servlet or service and rendering it through EL and tag libraries.

8.3 Expression

A JSP expression uses <%= ... %> to evaluate an expression and write its result to the response.

<p>Current year: <%= java.time.Year.now() %></p>

Expressions are evaluated while the page is processed. Their output is not automatically HTML-escaped, so avoid directly writing untrusted input using JSP expressions.

Comparison of JSP Scripting Elements

9. Expression Language (EL)

Expression Language (EL) provides a simpler way to access values exposed to a JSP from Java components, scoped attributes, JavaBeans, collections, and other supported data sources.

Instead of writing Java code to retrieve an attribute, EL can display it directly.

Example: Accessing an Attribute

<p>Welcome, ${studentName}!</p>

If a servlet stores the value Aarav in a request attribute named studentName, the JSP displays the corresponding value.

EL with JavaBean Properties

Suppose the application contains a JavaBean named Student with a public getter called getName(). If the bean is stored in an attribute named student, the following expression accesses its name property:

<p>Student Name: ${student.name}</p>

EL property access uses the bean's accessible property methods or supported property resolution. It is not a direct reference to an arbitrary private field.

Common EL Examples

10. JSP Implicit Objects

JSP provides implicit objects that can be used directly in traditional JSP scripting elements. EL also provides its own set of implicit objects, such as param, requestScope, and sessionScope. These two groups overlap conceptually but are not identical.

Traditional JSP Implicit Objects

EL Implicit Objects

11. JSP Scopes

JSP applications use scopes to control how long an attribute remains available and which components can access it. Choosing the right scope helps prevent data from being stored longer than necessary.

Example: Request Scope

A servlet can prepare a value and forward the request to a JSP.

// Inside a servlet
request.setAttribute("message", "Welcome to JSP");
request.getRequestDispatcher("/welcome.jsp")
       .forward(request, response);

The JSP can display the message with EL:

<h2>${requestScope.message}</h2>

Request scope is suitable when data is needed only to render the current response. Avoid placing large or sensitive objects into session or application scope without a clear requirement.

12. JSP Standard Actions

JSP standard actions are XML-style tags that perform defined operations during request processing. They are different from directives, which provide instructions for the translation phase.

12.1 jsp:include

The jsp:include action includes the output of another resource at request-processing time.

<jsp:include page="header.jsp" />

<main>
    <h2>Student Dashboard</h2>
</main>

<jsp:include page="footer.jsp" />

12.2 jsp:forward

The jsp:forward action forwards the current request to another resource within the application.

<jsp:forward page="welcome.jsp" />

After forwarding, the target resource processes the request. Use forwarding when the server should transfer processing to another resource rather than returning the current page's normal output.

12.3 jsp:param

The jsp:param action supplies a parameter to a JSP include or forward action.

<jsp:include page="greeting.jsp">
    <jsp:param name="user" value="Aarav" />
</jsp:include>

The included resource can access the parameter using the appropriate request parameter mechanism, including EL such as ${param.user}.

12.4 jsp:useBean

The jsp:useBean action locates or creates a JavaBean in the specified scope when the bean is not already present there.

<jsp:useBean id="student"
    class="com.example.model.Student"
    scope="request" />

In modern applications, Java objects are commonly created in servlets, controllers, or service classes and passed to the view. Understanding jsp:useBean remains useful for JSP fundamentals and legacy projects.

12.5 jsp:getProperty and jsp:setProperty

These actions read or set a JavaBean property.

<jsp:getProperty name="student" property="name" />

<jsp:setProperty name="student"
    property="name"
    value="Aarav" />

Use these actions only when the bean and property types are configured appropriately. Avoid allowing untrusted request values to modify sensitive model properties without validation and authorization.

13. Introduction to JSTL

JSTL, commonly referred to as the Jakarta Standard Tag Library in modern Jakarta applications, provides reusable tags for common presentation tasks. It reduces the need to write Java scriptlets inside JSP pages.

Common Tag Categories

Example: Displaying a List of Students

<%@ taglib prefix="c"
    uri="jakarta.tags.core" %>

<h2>Student List</h2>

<ul>
    <c:forEach var="student" items="${students}">
        <li>${student.name}</li>
    </c:forEach>
</ul>

Here, the servlet or controller supplies a collection named students. The c:forEach tag iterates over the collection and generates one list item for each student.

Make sure the appropriate JSTL/Jakarta Tags implementation is included in the application when required by your server and packaging setup.

14. Processing HTML Forms with JSP and Servlets

HTML forms allow users to submit information to a Java web application. A servlet usually receives and validates the form data, performs the required processing, and forwards the result to a JSP for display.

Step 1: Create the Form

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Student Registration</title>
</head>
<body>
    <h2>Student Registration</h2>

    <form action="register" method="post">
        <label for="studentName">Name:</label>
        <input type="text" id="studentName"
               name="studentName" required>

        <label for="email">Email:</label>
        <input type="email" id="email"
               name="email" required>

        <button type="submit">Register</button>
    </form>
</body>
</html>

Step 2: Process the Form in a Servlet

package com.example.web;

import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;

@WebServlet("/register")
public class RegistrationServlet extends HttpServlet {

    @Override
    protected void doPost(
            HttpServletRequest request,
            HttpServletResponse response)
            throws ServletException, IOException {

        request.setCharacterEncoding("UTF-8");

        String studentName =
                request.getParameter("studentName");
        String email =
                request.getParameter("email");

        if (studentName == null || studentName.isBlank()
                || email == null || email.isBlank()) {
            response.sendError(
                HttpServletResponse.SC_BAD_REQUEST,
                "Name and email are required."
            );
            return;
        }

        request.setAttribute("studentName", studentName);
        request.setAttribute("email", email);

        request.getRequestDispatcher("/registration-result.jsp")
               .forward(request, response);
    }
}

Step 3: Display the Result in JSP

<%@ page contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8" %>
<%@ taglib prefix="c"
    uri="jakarta.tags.core" %>

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Registration Result</title>
</head>
<body>
    <h2>Registration Submitted</h2>
    <p>Name: <c:out value="${requestScope.studentName}"/></p>
    <p>Email: <c:out value="${requestScope.email}"/></p>
</body>
</html>

Security note: This example performs basic server-side checks only. Real applications should validate input format, apply business rules, handle duplicate records, and use parameterized database operations. The JSTL c:out tag escapes XML/HTML-sensitive characters by default, helping reduce cross-site scripting risk when rendering ordinary text. Context-specific security controls are still necessary for JavaScript, URLs, CSS, and other output contexts.

15. JSP Error Handling

JSP applications should handle errors without exposing internal implementation details, database queries, file paths, or stack traces to users.

Using the errorPage Attribute

A JSP can designate another JSP to handle uncaught exceptions from the page.

<%@ page errorPage="error.jsp" %>

The error page can be configured to access the exception object:

<%@ page isErrorPage="true"
    contentType="text/html; charset=UTF-8" %>

<h2>An error occurred</h2>
<p>Please try again later or contact support.</p>

In production, log diagnostic details on the server using an appropriate logging framework. Display a generic error message to the user and avoid exposing the exception message or stack trace in the response.

16. JSP Lifecycle

The JSP lifecycle describes how the container manages a JSP page. Since a JSP is translated into a servlet, its lifecycle is closely related to the servlet lifecycle.

Main Lifecycle Stages

1. Translation: The JSP source is translated into servlet source code.
2. Compilation: The generated servlet is compiled.
3. Loading and instantiation: The container loads the generated class and creates an instance as required.
4. Initialization: The container initializes the generated servlet.
5. Request processing: The generated servlet processes requests and generates responses.
6. Destruction: The container may invoke the destruction lifecycle method when the generated servlet is taken out of service.

Lifecycle Diagram

JSP Source File
      |
      v
Translation into Servlet
      |
      v
Compilation
      |
      v
Servlet Initialization
      |
      v
Request Processing
      |
      v
Response Generation
      |
      v
Servlet Destruction

Translation and compilation are generally performed when the JSP is first needed or when recompilation is required. They do not necessarily occur on every request.

17. Best Practices for JSP Development

• Use JSP primarily for presentation and rendering.
• Keep database access and business logic in service and data-access classes rather than embedding them in JSP pages.
• Use servlets or controllers to process requests and prepare data for the view.
• Prefer EL and tag libraries over scriptlets for readable and maintainable pages.
• Use request scope for data that is only needed to render the current request.
• Choose session and application scopes carefully to avoid unnecessary memory usage.
• Use UTF-8 consistently for source files, requests, and responses.
• Escape untrusted data appropriately before rendering it in HTML.
• Validate form input on the server even when browser-side validation is present.
• Use parameterized SQL queries through an appropriate data-access layer.
• Avoid storing mutable request-specific data in JSP declaration fields.
• Use shared JSP fragments or templates for repeated presentation elements.
• Show user-friendly error pages and log technical details securely.
• Ensure JSP, Servlet, and JSTL dependencies match the application server version.

18. Common JSP Errors and Troubleshooting

19. Practical Project: Student Information Display System

Project objective: Create a basic web application that accepts student information, processes it in a servlet, and displays the result through a JSP page.

Project Requirements

• A registration form for student name, email, and course.
• A servlet to receive and validate the submitted data.
• Request attributes to pass data from the servlet to the JSP.
• A JSP result page using Expression Language.
• Output escaping for user-supplied text.
• A friendly error response when required fields are missing.

Implementation Steps

1. Create a Java web application and configure a compatible servlet container.
2. Create the registration form as an HTML or JSP page.
3. Create a servlet mapped to the form's action URL.
4. Read form parameters and validate them on the server.
5. Store validated values as request attributes.
6. Forward the request to the result JSP.
7. Display the values using EL and suitable escaping.
8. Test valid submissions, missing fields, special characters, and invalid input.
9. As an extension, store validated student records in a database through a service or DAO layer.

Expected Learning Outcomes

• Understand the role of JSP in the presentation layer.
• Understand how a servlet forwards data to a JSP.
• Use EL to access request attributes.
• Recognize directives, standard actions, and JSTL tags.
• Apply basic server-side validation and output-escaping practices.

20. Practice Exercises

1. Create a JSP page that displays a welcome message and the current year.
2. Use a page directive to configure the response content type and encoding.
3. Create a shared header and footer using the include directive.
4. Pass a message from a servlet to a JSP using request scope.
5. Display JavaBean properties using Expression Language.
6. Create a form that submits data to a servlet using the POST method.
7. Use JSTL c:if to display a message conditionally.
8. Use JSTL c:forEach to display a list of students or products.
9. Create a custom error page and test it with a controlled error scenario.
10. Refactor a JSP scriptlet example to use a servlet, EL, and JSTL instead.

21. Interview Questions and Answers

Q1. What is JSP?

Answer: JSP is a server-side Java technology for creating dynamic web pages using template text, JSP elements, Expression Language, and tag libraries.

Q2. What is the main purpose of JSP?

Answer: JSP is commonly used to render the presentation layer of a Java web application and display data prepared by Java components.

Q3. How does a JSP page execute?

Answer: The JSP container translates the JSP into a servlet, compiles it when necessary, and executes the generated servlet to produce the response.

Q4. What is the difference between JSP and a servlet?

Answer: JSP provides a template-oriented way to create dynamic content, while a servlet is a Java component typically used to process requests and coordinate application behavior.

Q5. What is a JSP directive?

Answer: A directive provides instructions to the JSP container. The main types are the page directive, include directive, and taglib directive.

Q6. What are JSP scripting elements?

Answer: The traditional scripting elements are declarations, scriptlets, and expressions, written using <%! ... %>, <% ... %>, and <%= ... %>.

Q7. What is Expression Language?

Answer: EL provides concise expressions for accessing scoped attributes, JavaBean properties, request parameters, and other supported values.

Q8. What is JSTL?

Answer: JSTL, or the Jakarta Standard Tag Library in modern Jakarta applications, provides reusable tags for common view operations such as iteration and conditional rendering.

Q9. What is the difference between the include directive and jsp:include?

Answer: The include directive incorporates file content during translation, while jsp:include includes the output of another resource at request-processing time.

Q10. What are JSP scopes?

Answer: Page, request, session, and application scopes determine the visibility and lifetime of attributes.

Q11. How can a servlet pass data to a JSP?

Answer: The servlet can store data in request attributes using setAttribute() and forward the request to a JSP, which can access the data using EL.

Q12. What is a JSP implicit object?

Answer: An implicit object is made available by the JSP environment without requiring the developer to declare it explicitly, such as request, response, out, and session.

Q13. Why should scriptlets be avoided in new JSP code?

Answer: Scriptlets mix Java logic with presentation markup and can make code harder to maintain. EL, tag libraries, servlets, and Java service classes provide better separation of concerns.

Q14. How can JSP output be made safer?

Answer: Validate input on the server and escape untrusted output for the context in which it is rendered. JSTL c:out can help escape ordinary HTML text, but other contexts require appropriate handling.

Q15. What is the JSP lifecycle?

Answer: The main stages include translation, compilation, loading and instantiation, initialization, request processing, and destruction.

22. Quick Revision Checklist

• JSP is used to create dynamic server-side web pages.
• A JSP page is translated into a servlet by the JSP container.
• Servlets commonly handle requests while JSP pages render views.
• The page, include, and taglib directives configure JSP processing.
• Declarations, scriptlets, and expressions are traditional JSP scripting elements.
• Expression Language accesses scoped attributes and bean properties.
• JSTL supports reusable presentation operations such as loops and conditions.
• JSP scopes include page, request, session, and application.
• Servlets can pass data to JSP pages using request attributes.
• Use server-side validation and context-appropriate output escaping.
• Keep business logic and database access out of JSP presentation pages.
• Ensure the JSP and Servlet API versions match the deployed server.

23. Conclusion

JavaServer Pages is an important topic in Advanced Java because it provides a template-based way to generate dynamic web content. Understanding JSP processing, directives, scripting elements, Expression Language, implicit objects, scopes, standard actions, and JSTL helps developers build more organized Java web applications.

In modern JSP development, the recommended approach is to keep business logic in Java classes and use servlets or controllers to prepare data for JSP views. EL and tag libraries can then render that data with less embedded Java code, improving readability, maintainability, and security.

Continue learning through the Advanced Java Training Course, register for a course demo, or explore the JustAcademy website.